home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / filesyst / dosfs / dmsdosfs.000 / dmsdosfs / dmsdosfs-0.6.9b / dmsdos_lfn.c < prev    next >
C/C++ Source or Header  |  1996-07-31  |  12KB  |  451 lines
  1. /*
  2. dmsdos_lfn.c
  3.  
  4. long filename support for dmsdos filesystem
  5.  
  6. ******************************************************************************
  7. DMSDOS (Doublespace/Drivespace compressed MSDOS filesystem) for Linux
  8. written 1995,1996 by Frank Gockel
  9.  
  10.     (C) Copyright 1995,1996 by Frank Gockel
  11.  
  12. Some code of the dmsdos filesystem has been copied from the msdos filesystem
  13. so there are the following additional copyrights:
  14.  
  15.     (C) Copyright 1992,1993 by Werner Almesberger (msdos filesystem)
  16.     (C) Copyright 1994,1995 by Jacques Gelinas (mmap code)
  17.     (C) Copyright 1992-1995 by Linus Torvalds
  18.  
  19. The DMSDOS filesystem was inspired by the THS filesystem (a simple doublespace
  20. DS-0-2 compressed read-only filesystem) written 1994 by Thomas Scheuermann.
  21.  
  22. The DMSDOS filesystem is distributed under the Gnu General Public Licence.
  23. See file COPYING for details.
  24. ******************************************************************************
  25.  
  26. */
  27.  
  28. #include<linux/fs.h>
  29. #include <linux/errno.h>
  30. #include <linux/string.h>
  31. #include <linux/kernel.h>
  32. #include<linux/msdos_fs.h>
  33. #include<linux/dmsdos_fs.h>
  34.  
  35. extern Dblsb dblsb[];
  36.  
  37. /* should be enough */
  38. #define MAX_LFN_DIRENTRIES 25
  39.  
  40. unsigned char checksum(unsigned char * buf)
  41. { int i;
  42.   unsigned char sum=0;
  43.   
  44.   for(i=0;i<11;++i)
  45.   { if(sum&1)sum=sum/2+0x80;
  46.     else sum/=2;
  47.     sum+=buf[i];
  48.   }
  49.   return sum;
  50. }
  51.  
  52. /* reads lfn direntry: real direntry in buf, filename in longname
  53.    if it is a short name, longname is setup right (lower case)
  54.    returns ino of short name/error code
  55.    if lfn_inos!=NULL: returns list of inos in reverse order (first=short name)
  56. */
  57.  
  58. int read_lfn_direntry(struct super_block*sb,int dirstartclust,int cvfnr,
  59.                        int entrynr, char*longname, unsigned char*buf,
  60.                        int * lfn_inos)
  61. { int ino;
  62.   unsigned char buf2[32];
  63.   char *name;
  64.   int islong;
  65.   int order,i;
  66.   unsigned char checks;
  67.   
  68.   /*printk("DMSDOS: read_lfn_direntry begin\n");*/
  69.   
  70.   /* initialize with zeros -- for safety */
  71.   if(lfn_inos)for(i=0;i<MAX_LFN_DIRENTRIES;++i)lfn_inos[i]=0;
  72.    
  73.   islong=dblsb[cvfnr].s_support_lfn&1;
  74.   order=0;
  75.   name=longname;
  76.   *name='\0';
  77.   
  78.   ino=read_dbl_direntry(sb,dirstartclust,cvfnr,entrynr,buf);
  79.   if(ino<0)return ino;
  80.   if(lfn_inos)lfn_inos[order]=ino;
  81.   if(buf[0]==0||buf[0]==0xe5||(buf[11]&ATTR_VOLUME)!=0)return ino;
  82.   
  83.   checks=checksum(buf);
  84.   
  85.   if(entrynr==0)islong=0; /* first can't be long, but does never enter loop */
  86.   while(entrynr>0&&order<0x3f&&islong!=0)
  87.   { --entrynr;
  88.     ++order;
  89.     i=read_dbl_direntry(sb,dirstartclust,cvfnr,entrynr,buf2);
  90.     if(lfn_inos)lfn_inos[order]=i;
  91.     if(checks!=buf2[13]||(buf2[0]&0x3f)!=order||buf2[11]!=0xf)
  92.     { /* if((buf2[0]&0x3f)==order&&buf2[11]==0xf)
  93.          printk("DMSDOS: wrong checksum: formula=%d is=%d\n",checks,buf2[13]);
  94.       */
  95.       islong=0;
  96.       if(lfn_inos)lfn_inos[1]=0; /* cut lfn_inos array (rest after a zero is iqnored) */
  97.       break;
  98.     }
  99.     for(i=0;i<5;++i)
  100.     { if(buf2[1+2*i]==255&&buf2[2+2*i]==255)break; 
  101.       *(name++)=buf2[1+2*i];
  102.     }
  103.     for(i=0;i<6;++i)
  104.     { if(buf2[14+2*i]==255&&buf2[15+2*i]==255)break;
  105.       *(name++)=buf2[14+2*i];
  106.     }
  107.     for(i=0;i<2;++i)
  108.     { if(buf2[28+2*i]==255&&buf2[29+2*i]==255)break;
  109.       *(name++)=buf2[28+2*i];
  110.     }
  111.     if(buf2[0]&0x40)break;
  112.   }
  113.   *name='\0';
  114.   
  115.   if(islong==0)
  116.   { name=longname;
  117.     for(i=0;i<8;++i)
  118.     { if(buf[i]==' ')break;
  119.       if( (dblsb[cvfnr].s_support_lfn&8)!=0 &&buf[i]>='A'&&buf[i]<='Z')
  120.            *(name++)=buf[i]+32;
  121.       else *(name++)=buf[i];
  122.     }
  123.     if(buf[8]!=' ')*(name++)='.';
  124.     for(i=8;i<11;++i)
  125.     { if(buf[i]==' ')break;
  126.       if( (dblsb[cvfnr].s_support_lfn&8)!=0 &&buf[i]>='A'&&buf[i]<='Z')
  127.            *(name++)=buf[i]+32;
  128.       else *(name++)=buf[i];
  129.     }
  130.     *name='\0';                                   
  131.   }
  132.   
  133.   /*printk("DMSDOS: read_lfn_direntry: name found %s\n",longname);*/
  134.   return ino; 
  135. } 
  136.  
  137. /* returns ino */
  138. int scan_dbl_dir_4_lfn(struct super_block*sb, int dirstartclust,
  139.                        const char*tofind1,int len,int cvfnr,int*lfn_inos)
  140. { int entrynr,i,ppos;
  141.   char name[257];
  142.   unsigned char buf[32];
  143.   int ino;
  144.   char tofind2[257];
  145.   const char * tofind;
  146.  
  147.   /*printk("DMSDOS: scan_dbl_dir_4_lfn: searching for %s\n",tofind);*/
  148.   
  149.   if((dblsb[cvfnr].s_support_lfn&1)==0)
  150.   { /* case should not be significant ... 
  151.        so convert upper case in tofind to lower case
  152.     */
  153.     for(i=0;i<len;++i)
  154.     { if(tofind1[i]>='A'&&tofind1[i]<='Z')tofind2[i]=tofind1[i]-'A'+'a';
  155.       else tofind2[i]=tofind1[i];
  156.     }
  157.     
  158.     /* now match the 8.3 convention */
  159.     
  160.     /* find first '.' */
  161.     ppos=0;
  162.     for(i=0;i<len;++i)
  163.     { if(tofind2[i]=='.')ppos=i;
  164.     }
  165.     if(ppos==0&&len>8)len=8;
  166.     if(ppos>0&&ppos<=8&&len-ppos>4)len=ppos+4;
  167.     if(ppos>8)
  168.          { tofind2[8]='.';
  169.            if(len>ppos+1)tofind2[9]=tofind2[ppos+1];
  170.            if(len>ppos+2)tofind2[10]=tofind2[ppos+2];
  171.            if(len>ppos+3)tofind2[11]=tofind2[ppos+3];
  172.            /* subtract number of characters that have been cut off
  173.               before the '.' */
  174.            len -=(ppos-8);
  175.            /* limit total length */
  176.            if(len>12)len=12;  /* incl. '.' */
  177.          }
  178.     tofind=tofind2;
  179.   }
  180.   else tofind=tofind1;
  181.   
  182.   entrynr=0;
  183.   do
  184.   { ino=read_lfn_direntry(sb,dirstartclust,cvfnr,entrynr,name,buf,lfn_inos);
  185.     if(ino<0)return ino;
  186.     if((buf[11]&ATTR_VOLUME)==0&&buf[0]!=0xe5)
  187.     { /*if(strncmp(name,tofind,len)==0)return ino;*/
  188.       /*if(strcmp(name,tofind)==0)return ino;*/
  189.       if(strlen(name)==len&&strncmp(name,tofind,len)==0)return ino;
  190.     }
  191.     ++entrynr;
  192.   }
  193.   while(buf[0]!=0);
  194.   return -ENOENT;
  195. }
  196.  
  197. int dmsdos_get_lfn_entry(struct inode *dir, loff_t *pos,unsigned char * buf,
  198.                          char*longname)
  199. {
  200.   int entrynr;
  201.   int ino;
  202.   int clust;
  203.   int cvfnr;
  204.                              
  205.   entrynr = (*pos)>>5;
  206.   /*printk("DMSDOS: get_lfn_entry nr %d\n",entrynr);*/
  207.   *pos += 32;
  208.   if((cvfnr=dbltest(dir))!=0)cvfnr=(cvfnr>>DMSDOS_CVFNR_BITS)-1;
  209.   else cvfnr=(dir->i_ino>>DMSDOS_CVFNR_BITS)-1;
  210.   clust=MSDOS_I(dir)->i_start;/*dbl_inode2startcluster(dir);*/
  211.   ino=read_lfn_direntry(dir->i_sb,clust,cvfnr,entrynr,longname,buf,NULL);
  212.   /* break on zero entry */
  213.   if(buf[0]==0)return -ENOENT;
  214.   /*printk("DMSDOS: dmsdos_get_lfn_entry: found %s\n",longname);*/
  215.   return ino;
  216. }
  217.  
  218. /* returns 0 if okay */
  219. int remove_lfn_entry(struct super_block*sb, int dirstartclust,
  220.                      const char*tofind, int len, int cvfnr)
  221. { int lfn_inos[MAX_LFN_DIRENTRIES];
  222.   int i;
  223.   struct buffer_head*bh;
  224.   int dblsec,offs;
  225.   
  226.   i=scan_dbl_dir_4_lfn(sb,dirstartclust,tofind,len,cvfnr,lfn_inos);
  227.   if(i<0)return i;
  228.   
  229.   i=0;
  230.   while(lfn_inos[i]!=0&&i<MAX_LFN_DIRENTRIES)
  231.   {  dblsec=(lfn_inos[i]&DMSDOS_ORIGINO_MASK)>>4;
  232.      offs=(lfn_inos[i]&0xf)<<5;       
  233.      bh=read_dbl_sector(sb,dblsec,cvfnr);
  234.      if(bh==NULL)return -EIO;
  235.      if(i>0&&bh->b_data[offs+11]!=0xf) /* oh oh -- this isn't a long name */
  236.      { bh_free(sb,bh);
  237.        break;
  238.      }
  239.      bh->b_data[offs]=0xe5;
  240.      bh->b_data[offs+11]&=~ATTR_VOLUME;
  241.      bh_dirty(sb,bh);
  242.      bh_free(sb,bh);
  243.      ++i;
  244.   }
  245.   
  246.   return 0;
  247. }
  248.  
  249. int must_be_long(const char*name,int len,int*p_ppos,int cvn)
  250. { int ppos;
  251.   int i;
  252.  
  253.   /* check point position */
  254.  
  255.   ppos=-1;
  256.   for(i=0;i<len;++i)
  257.   { if(name[i]=='.')
  258.     { if(ppos<0)ppos=i;
  259.       else
  260.       { if(p_ppos)*p_ppos=ppos;
  261.         return 1;
  262.       }
  263.     }
  264.   }
  265.   
  266.   if(p_ppos)*p_ppos=ppos;
  267.   if(ppos==-1&&len>8)return 1;
  268.   if(ppos==0||ppos>8)return 1;
  269.   if(len>12)return 1;
  270.   if(ppos==len)return 1;
  271.   if(ppos>0&&len-ppos>4) return 1;
  272.   
  273.   /* check for undesired characters */
  274.   
  275.   for(i=0;i<len;++i)
  276.   { if(name[i]<=32)return 1;
  277.     if(name[i]==34||name[i]==92)return 1;
  278.     if(name[i]>=42&&name[i]<=44)return 1;
  279.     if(name[i]>=59&&name[i]<=63)return 1;
  280.     if(name[i]==124||name[i]>=126)return 1;
  281.     if(name[i]>='a'&&name[i]<='z'&&cvn==0)return 1;
  282.     if(name[i]>='A'&&name[i]<='Z'&&cvn!=0)return 1;
  283.   }
  284.   
  285.   return 0;
  286. }
  287.  
  288. /* must be called locked */
  289. /* longname must not already exist (no check here) */
  290. /* returns ino of (incomplete) short entry */
  291. int create_lfn_entry(struct super_block*sb, int dirstartclust,
  292.                      const char*longname, int len, int cvfnr)
  293. {  /*printk("DMSDOS: create_lfn_entry: Not yet implemented, sorry.\n");
  294.      return -EIO;*/
  295.      
  296.    int ilong;
  297.    char shortname[12];
  298.    int i,j;
  299.    int ppos,spos,pos;
  300.    char numstr[10];
  301.    int versuch;
  302.    int lnumstr;
  303.    int req;
  304.    int lfn_inos[MAX_LFN_DIRENTRIES];
  305.    int dblsec;
  306.    int offs;
  307.    struct buffer_head * bh;
  308.    int checks;
  309.    int ino;
  310.    
  311.    if(len>255)return -EINVAL;
  312.    
  313.    strcpy(shortname,"           ");
  314.           /*         12345678EXT   */
  315.    
  316.    ilong=(dblsb[cvfnr].s_support_lfn&16) ? 1 :
  317.          must_be_long(longname,len,&ppos,dblsb[cvfnr].s_support_lfn&8);
  318.    
  319.    if(ilong)strcpy(shortname,"~~~~~~~~   ");
  320.            /*                 12345678EXT       */
  321.            
  322.    if(ppos<=0)ppos=len;
  323.    
  324.    for(i=0;i<ppos&&i<8;++i)
  325.    { shortname[i]=longname[i];
  326.      if(longname[i]<=32)shortname[i]='~';
  327.      if(longname[i]==34||longname[i]==92)shortname[i]='~';
  328.      if(longname[i]>=42&&longname[i]<=44)shortname[i]='~';
  329.      if(longname[i]>=59&&longname[i]<=63)shortname[i]='~';
  330.      if(longname[i]>=97&&longname[i]<=122)shortname[i]=longname[i]-32;
  331.      if(longname[i]==124||longname[i]>=126)shortname[i]='~';
  332.    }
  333.    
  334.    if(ppos<len)
  335.    { for(i=ppos+1,j=8;i<len&&j<11;++i,++j)
  336.      { shortname[j]=longname[i];
  337.        if(longname[i]<=32)shortname[j]='~';
  338.        if(longname[i]==34||longname[i]==92)shortname[j]='~';
  339.        if(longname[i]>=42&&longname[i]<=44)shortname[j]='~';
  340.        if(longname[i]>=59&&longname[i]<=63)shortname[j]='~';
  341.        if(longname[i]>=97&&longname[i]<=122)shortname[j]=longname[i]-32;
  342.        if(longname[i]==124||longname[i]>=126)shortname[j]='~';
  343.      }
  344.    }
  345.    
  346.    if(ilong)
  347.    {
  348.      versuch=0;
  349.    
  350.      do
  351.      { ++versuch;
  352.        sprintf(numstr,"~%d",versuch);
  353.        lnumstr=strlen(numstr);
  354.        spos=8-lnumstr;
  355.        for(i=0;i<lnumstr;++i)shortname[i+spos]=numstr[i];
  356.      }
  357.      while(scan_dbl_dir_4_filename(sb,dirstartclust,shortname,11,cvfnr)>0);
  358.    }
  359.  
  360.    /* okay, everything is set up now */
  361.    
  362.    if(!ilong)req=1;
  363.    else req=2+((len-1)/13);
  364.    
  365.    ino=scan_dbl_dir_4_n_empty(sb,dirstartclust,cvfnr,req,lfn_inos);
  366.    if(ino<0)return ino;
  367.    
  368.    /* now write the short entry */
  369.    dblsec=(ino&DMSDOS_ORIGINO_MASK)>>4;
  370.    offs=(ino&0xf)<<5;
  371.    bh=read_dbl_sector(sb,dblsec,cvfnr);
  372.    if(bh==NULL)return -EIO;
  373.    bh->b_data[offs+11]=ATTR_VOLUME; /* ignore this entry as it is incomplete */
  374.    for(i=0;i<11;++i)bh->b_data[offs+i]=shortname[i];
  375.    bh_dirty(sb,bh);
  376.    bh_free(sb,bh);
  377.    
  378.    if(!ilong)return ino;
  379.    
  380.    checks=checksum(shortname);
  381.    
  382.    pos=0;
  383.    
  384.    for(j=1;j<req;++j)
  385.    {  dblsec=(lfn_inos[j]&DMSDOS_ORIGINO_MASK)>>4;
  386.       offs=(lfn_inos[j]&0xf)<<5;
  387.       bh=read_dbl_sector(sb,dblsec,cvfnr);
  388.       if(bh==NULL)return -EIO;
  389.       
  390.       bh->b_data[offs]=(j==req-1)?j|0x40:j;
  391.       bh->b_data[offs+11]=0xf;
  392.       bh->b_data[offs+13]=checks;
  393.       bh->b_data[offs+26]=0;
  394.       bh->b_data[offs+27]=0;
  395.       
  396.       for(i=0;i<5;++i)
  397.       {  if(pos<len)
  398.          { bh->b_data[offs+2+2*i]=0;
  399.            bh->b_data[offs+1+2*i]=longname[pos];
  400.          }
  401.          else if(pos==len)
  402.          { bh->b_data[offs+1+2*i]=0;
  403.            bh->b_data[offs+2+2*i]=0;
  404.          }
  405.          else
  406.          { bh->b_data[offs+1+2*i]=255;
  407.            bh->b_data[offs+2+2*i]=255;
  408.          }
  409.          ++pos;
  410.       }
  411.  
  412.       for(i=0;i<6;++i)
  413.       {  if(pos<len)
  414.          { bh->b_data[offs+15+2*i]=0;
  415.            bh->b_data[offs+14+2*i]=longname[pos];
  416.          }
  417.          else if(pos==len)
  418.          { bh->b_data[offs+14+2*i]=0;
  419.            bh->b_data[offs+15+2*i]=0;
  420.          }
  421.          else
  422.          { bh->b_data[offs+14+2*i]=255;
  423.            bh->b_data[offs+15+2*i]=255;
  424.          }
  425.          ++pos;
  426.       }
  427.       
  428.       for(i=0;i<2;++i)
  429.       {  if(pos<len)
  430.          { bh->b_data[offs+29+2*i]=0;
  431.            bh->b_data[offs+28+2*i]=longname[pos];
  432.          }
  433.          else if(pos==len)
  434.          { bh->b_data[offs+28+2*i]=0;
  435.            bh->b_data[offs+29+2*i]=0;
  436.          }
  437.          else
  438.          { bh->b_data[offs+28+2*i]=255;
  439.            bh->b_data[offs+29+2*i]=255;
  440.          }
  441.          ++pos;
  442.       }
  443.                
  444.       bh_dirty(sb,bh);
  445.       bh_free(sb,bh);
  446.                         
  447.    } 
  448.    
  449.    return ino;                                  
  450. }
  451.